home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Eudora 1.3.1 / source / sendmail.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  29.6 KB  |  1,053 lines  |  [TEXT/MPS ]
  1. #define FILE_NUM 34
  2. /* Copyright (c) 1990-1992 by the University of Illinois Board of Trustees */
  3. /************************************************************************
  4.  * functions for dealing with a sendmail (or other?) smtp server
  5.  ************************************************************************/
  6. #pragma load EUDORA_LOAD
  7. #pragma segment SMTP
  8. typedef enum
  9. {
  10.     helo=1, mail, rcpt, data, rset, send, soml, saml,
  11.     vrfy, expn, help, noop, quit, turn
  12. } SMTPEnum;
  13.  
  14. #define CMD_BUFFER 1024
  15. #define IsAddressHead(head) (head==TO_HEAD || head==BCC_HEAD || head==CC_HEAD)
  16. typedef struct wdsEntry *WDSPtr;
  17. /************************************************************************
  18.  * declarations for private routines
  19.  ************************************************************************/
  20.     int DoIntroductions(void);
  21.     int SayByeBye(void);
  22.     int SendCmd(int cmd, UPtr args);
  23.     int SendCmdGetReply(int cmd, UPtr args, Boolean chatter);
  24.     int SendHeaderLine(int header,TEHandle teh);
  25.     int SendAttachments(TEHandle teh,Boolean doWrap,Boolean plainText);
  26.     int SMTPCmdError(int cmd, UPtr args, UPtr message);
  27.     void PrimeProgress(MessType **messH);
  28.     int WannaSend(MyWindowPtr win);
  29.     void GrabSignature(void);
  30.     short SendPlain(short vRef,long dirId,UPtr name,Boolean doWrap);
  31.     UPtr PriorityHeader(UPtr buffer,Byte priority);
  32. int sErr;
  33. UHandle Signature=nil;
  34. short SendEm(WDSPtr entries,WDSPtr *current);
  35. short AddWDS(WDSPtr entries, WDSPtr *current,Uptr bf,long len,short maxC);
  36.  
  37. /************************************************************************
  38.  * Public routines
  39.  ************************************************************************/
  40. /************************************************************************
  41.  * StartSMTP - initiate a connection with the specified SMTP server
  42.  ************************************************************************/
  43. int StartSMTP(UPtr serverName, short port)
  44. {
  45.     if (UUPCOut) sErr=UUPCPrime(serverName);
  46.     else if (!(sErr=ConnectTrans(serverName,port,False)))
  47.         sErr=DoIntroductions();
  48.     GrabSignature();
  49.     return(sErr);
  50. }
  51.  
  52. /************************************************************************
  53.  * SendMessage - send a message to the SMTP server
  54.  ************************************************************************/
  55. int SendMessage(TOCType **tocH,int sumNum)
  56. {
  57.     Str255 buffer;
  58.     MessHandle messH;
  59.     
  60.     /*
  61.      * handle open, dirty windows
  62.      */
  63.     if (!(messH=SaveB4Send(tocH,sumNum))) return(1);
  64.     
  65.     /*
  66.      * Log, if we must
  67.      */
  68.     GetWTitle((*messH)->win,buffer);
  69.     ComposeLogR(LOG_SEND,nil,SENDING,buffer);
  70.     
  71.     /*
  72.      * reset SMTP
  73.      */
  74.     sErr = SendCmdGetReply(rset,nil,True);
  75.     if (sErr/100 != 2) return(sErr);
  76.     sErr = 0;
  77.     
  78.     /*
  79.      * envelope
  80.      */
  81.     GetReturnAddr(buffer,False);
  82.     sErr = SendCmdGetReply(mail,buffer,True);
  83.     if (sErr/100 != 2) return(sErr);
  84.     sErr = 0;
  85.     
  86.     if (WrapWrong) OffsetWindow((*messH)->win);
  87.     
  88.     if (sErr=DoRcptTos(messH,True)) goto done;
  89.     
  90.     /*
  91.      * and the body
  92.      */
  93.     sErr = SendCmdGetReply(data,nil,True);
  94.     if (sErr/100 != 3) goto done;
  95.     sErr = 0;
  96.     
  97.     if (sErr=TransmitMessage(messH,True)) goto done;
  98.     
  99.     TimeStamp(tocH,sumNum,GMTDateTime(),ZoneSecs());
  100.             
  101. done:
  102.     CloseMyWindow((*messH)->win);
  103.     (void)ComposeLogR(LOG_SEND,nil,sErr?FAILED:SUCCEEDED,sErr);
  104.     return(sErr);
  105. }
  106.  
  107. /************************************************************************
  108.  * EndSMTP - done talking to SMTP
  109.  ************************************************************************/
  110. int EndSMTP()
  111. {
  112.     if (UUPCOut) UUPCDry();
  113.     else
  114.     {
  115.         if (sErr || CommandPeriod) SilenceTrans(True);
  116.         if ((!sErr || (sErr<600 && sErr>=400)) && !(sErr=SayByeBye()))
  117.             DisTrans();
  118.         sErr = DestroyTrans();
  119.     }
  120.     if (Signature) ZapHandle(Signature);
  121.     return(sErr);
  122. }
  123.  
  124. /************************************************************************
  125.  * SMTPError - return the last SMTP error
  126.  ************************************************************************/
  127. int SMTPError(void)
  128. {
  129.     return (sErr);
  130. }
  131.  
  132. /************************************************************************
  133.  * Private routines
  134.  ************************************************************************/
  135. /************************************************************************
  136.  * DoIntroductions - take care of the beginning of the SMTP protocol
  137.  ************************************************************************/
  138. int DoIntroductions(void)
  139. {
  140.     Str255 buffer;
  141.     
  142.     /*
  143.      * get banner from the remote end
  144.      */
  145.     sErr = GetReply(buffer,sizeof(buffer),True);
  146.     if (sErr/100 != 2) return(sErr);
  147.     sErr = 0;
  148.     /*
  149.      * tell it who we are
  150.      */
  151.     sErr = SendCmdGetReply(helo,WhoAmI(buffer),True);
  152.     return((sErr/100 != 2) ? sErr :  (sErr=0));
  153. }
  154.  
  155. /************************************************************************
  156.  * SayByeBye - take care of the end of the SMTP protocol
  157.  ************************************************************************/
  158. int SayByeBye(void)
  159. { 
  160.     sErr = SendCmdGetReply(quit,nil,False);
  161.     return((sErr/100 != 2) ? sErr : (sErr=0));    
  162. }
  163.  
  164. /************************************************************************
  165.  * SendCmd - send an smtp command, with optional arguments
  166.  ************************************************************************/
  167. int SendCmd(int cmd, UPtr args)
  168. {
  169.     Byte buffer[CMD_BUFFER];
  170.  
  171.     GetRString(buffer,SMTP_STRN+cmd);
  172.     if (args && *args)
  173.         PCat(buffer,args);
  174.     Progress(NoBar,buffer); 
  175.     PCat(buffer,NewLine);
  176.     
  177.     if (sErr=SendTrans(1,buffer+1,*buffer)) return(sErr);
  178.     
  179.     return(noErr);
  180. }
  181.  
  182. /************************************************************************
  183.  * SMTPCmdError - report an error for an SMTP command
  184.  ************************************************************************/
  185. int SMTPCmdError(int cmd, UPtr args, UPtr message)
  186. {
  187.     Str255 theCmd;
  188.     Str255 theError;
  189.     int err;
  190.  
  191.     GetRString(theCmd,2800+cmd);
  192.     if (args && *args)
  193.         PCat(theCmd,args);
  194.     strcpy(theError+1,message);
  195.     *theError = strlen(theError+1);
  196.     if (theError[*theError]=='\012') (*theError)--;
  197.     if (theError[*theError]=='\015') (*theError)--;
  198.     MyParamText(theCmd,theError,"\pSMTP","");
  199.     err = ReallyDoAnAlert(PROTO_ERR_ALRT,Note);
  200.     return(err);
  201. }
  202.  
  203. /************************************************************************
  204.  * SendCmdGetReply - send an smtp command, with optional arguments, and
  205.  * wait for the reply.    Returns reply code.
  206.  ************************************************************************/
  207. int SendCmdGetReply(int cmd, UPtr args, Boolean chatter)
  208. {
  209.     char buffer[CMD_BUFFER];
  210.     
  211.     if (sErr=SendCmd(cmd,args)) return(601);            /* error in transmission */
  212.     sErr = GetReply(buffer,sizeof(buffer),False);
  213.     if (sErr>399 && sErr<=600 && sErr!=550 && chatter)
  214.         SMTPCmdError(cmd,args,buffer);
  215.     return(sErr);
  216. }
  217.  
  218. /************************************************************************
  219.  * GetReply - get a reply to an SMTP command
  220.  ************************************************************************/
  221. int GetReply(UPtr buffer, int size, Boolean verbose)
  222. {
  223.     long rSize;
  224.     Str127 scratch;
  225.     char *cp;
  226.     short err;
  227.     
  228.     do
  229.     {
  230.         rSize = size;
  231.         if (sErr=RecvLine(buffer,&rSize)) return(602);    /* error receiving */
  232.         if (verbose)
  233.         {
  234.             *scratch = MIN(127,rSize);
  235.             strncpy(scratch+1,buffer,*scratch);
  236.             Progress(NoChange,scratch);
  237.         }
  238.         for (cp=buffer;cp<buffer+rSize && (*cp < ' ' || *cp>'~');cp++);
  239.         rSize -= cp-buffer;
  240.     }
  241.     while (rSize<3 ||
  242.                  !isdigit(cp[0])||!isdigit(cp[1])||!isdigit(cp[2]) ||
  243.                                  rSize>3 && cp[3]=='-');
  244.     cp[rSize] = 0;
  245.     err = atoi(cp);
  246.     if (verbose && err>399 && err<600) SMTPCmdError(nil,nil,buffer);
  247.     return(err);
  248. } 
  249.  
  250. /************************************************************************
  251.  * DoRcptTos - tell the remote sendmail who is getting the message
  252.  ************************************************************************/
  253. int DoRcptTos(MessType **messH, Boolean chatter)
  254. {
  255.     sErr=DoRcptTosFrom((*messH)->txes[TO_HEAD-1],chatter);
  256.     if (sErr) return(sErr);
  257.     sErr=DoRcptTosFrom((*messH)->txes[BCC_HEAD-1],chatter); 
  258.     if (sErr) return(sErr);
  259.     sErr=DoRcptTosFrom((*messH)->txes[CC_HEAD-1],chatter);
  260.     return(sErr);
  261. }
  262.  
  263. /************************************************************************
  264.  * DoRcptTosFrom - do the Rcpt to's from a particular TERec
  265.  ************************************************************************/
  266. int DoRcptTosFrom(TEHandle teh, Boolean chatter)
  267. {
  268.     Str255 toWhom;
  269.     UHandle addresses,rawAddresses;
  270.     UPtr address;
  271.  
  272.     sErr = 550;
  273.     if (rawAddresses=SuckAddresses((*teh)->hText,(*teh)->teLength,False))
  274.     {
  275.         sErr=200;
  276.         if (**rawAddresses)
  277.         {
  278.             addresses = ExpandAliases(rawAddresses,0,False);
  279.             DisposHandle(rawAddresses);
  280.             if (!addresses) return(sErr=500);
  281.             for (address=LDRef(addresses); *address; address += *address + 2)
  282.             {
  283.                 if (*address > MAX_ALIAS)
  284.                 {
  285.                     WarnUser(BAD_ADDRESS,0);
  286.                     sErr = 550;
  287.                     break;
  288.                 }
  289.                 if (UUPCOut)
  290.                 {
  291.                     if (sErr=UUPCWriteAddr(address)) break;
  292.                 }
  293.                 else
  294.                 {
  295.                     toWhom[0] = 1; toWhom[1] = '<';
  296.                     PCat(toWhom,address);
  297.                     PCatC(toWhom,'>');
  298.                     sErr = SendCmdGetReply(rcpt,toWhom,chatter);
  299.                     if (chatter && sErr==550)
  300.                         AlertStr(BAD_ADDR_ALRT,Stop,address);
  301.                     if (sErr/100 != 2) break;
  302.                 }
  303.             }
  304.             DisposHandle(addresses);
  305.         }
  306.         else
  307.             DisposHandle(rawAddresses);
  308.     }
  309.     return(sErr/100!=2 ? sErr : (sErr=0));
  310. }
  311.  
  312. /************************************************************************
  313.  * TransmitMessage - send a message to the remote sendmail
  314.  ************************************************************************/
  315. int TransmitMessage(MessType **messH, Boolean chatter)
  316. {
  317.     int header;
  318.     Str255 buffer;
  319.     long flags=(*(*messH)->tocH)->sums[(*messH)->sumNum].flags;
  320.     TEHandle body = (*messH)->txes[HEAD_LIMIT-1];
  321.     Byte priority;
  322.         
  323.     PrimeProgress(messH);
  324.  
  325.     /*
  326.      * extra headers
  327.      */
  328.     if (GetResource('STR#',EX_HEADERS_STRN))
  329.     {
  330.         for (header=1;;header++)
  331.         {
  332.             if (*GetRString(buffer,EX_HEADERS_STRN+header))
  333.             {
  334.                 if (sErr=SendTrans(2,buffer+1,*buffer,NewLine+1,*NewLine))
  335.                     return(600);
  336.             }
  337.             else break;
  338.         }
  339.     }
  340.  
  341.     /*
  342.      * real headers
  343.      */
  344.     priority = (*(*messH)->tocH)->sums[(*messH)->sumNum].priority;
  345.     priority = Prior2Display(priority);
  346.     if (priority!=3)
  347.     {
  348.         PriorityHeader(buffer,priority);
  349.         if (sErr=SendTrans(2,buffer+1,*buffer,NewLine+1,*NewLine))
  350.           return(600);
  351.     }
  352.     
  353.     BuildDateHeader(buffer,0);
  354.     if (*buffer && (sErr=SendTrans(2,buffer+1,*buffer,NewLine+1,*NewLine)))
  355.         return(600);
  356.     
  357.     for (header=1;header<HEAD_LIMIT;header++)
  358.         if (header!=BCC_HEAD && (sErr=SendHeaderLine(header,(*messH)->txes[header-1])))
  359.             return(600);
  360.     GiveTime();
  361.     
  362.     /*
  363.      * body
  364.      */
  365.     SendTrans(1,NewLine+1,*NewLine);
  366.     
  367.     if (WrapWrong)
  368.     {
  369.         LDRef(body);
  370.         sErr=SendBodyLines((*body)->hText,(*body)->teLength,0,
  371.                                              (flags&FLAG_WRAP_OUT)!=0,True,(*body)->lineStarts,
  372.                                              (*body)->nLines,False);
  373.         UL(body);
  374.         if (sErr) return(600);
  375.     }
  376.     else if (sErr=SendBodyLines((*body)->hText,(*body)->teLength,0,
  377.                                                  (flags&FLAG_WRAP_OUT)!=0,True,nil,0,False))
  378.         return(600);
  379.  
  380.     if ((flags & FLAG_SIG) && Signature && (sErr=SendBodyLines(Signature,
  381.              GetHandleSize(Signature),0,(flags&FLAG_WRAP_OUT)!=0,True,nil,0,False)))
  382.         return(600);
  383.     
  384.     if (sErr=SendAttachments((*messH)->txes[ATTACH_HEAD-1],
  385.                                                      (flags&FLAG_WRAP_OUT)!=0,
  386.                                                      (flags&FLAG_BX_TEXT)==0))
  387.         return(600);
  388.         
  389.     if (!UUPCOut &&
  390.             (sErr=SendTrans(3,NewLine+1,*NewLine,".",1,NewLine+1,*NewLine)))
  391.         return(600);
  392.     Progress(100,nil);
  393.     
  394.     if (!UUPCOut)
  395.     {
  396.         sErr = GetReply(buffer,sizeof(buffer),False);
  397.         if (sErr > 399 && chatter)
  398.             SMTPCmdError(data,"",buffer);
  399.     }
  400.     
  401.     return(sErr/100 != 2 ? sErr : (sErr=0));
  402. }         
  403.  
  404. /************************************************************************
  405.  * PriorityHeader: Build a priority header
  406.  ************************************************************************/
  407. UPtr PriorityHeader(UPtr buffer,Byte priority)
  408. {
  409.     return(ComposeRString(buffer,PRIORITY_FMT,HEADER_STRN+PRIORITY_HEAD,priority,PRIOR_STRN+priority));
  410. }
  411.  
  412. /************************************************************************
  413.  * These macros will help send bunches of lines at a time through MacTCP
  414.  * Note that A/UX has VERY limited WDS capabilities.
  415.  * There is also a problem with LC's and LC Ethernet cards, around 16
  416.  * somewhere.
  417.  ************************************************************************/
  418. #define NENTRIES 32
  419. #define ENTRYDECLARATIONS                                                                                             \
  420.     struct wdsEntry entries[NENTRIES];                                                                        \
  421.     WDSPtr *current=entries;                                                                                            \
  422.     short lastC,lastLen;                                                                                                    \
  423.     int sendCount = IsAUX() ? 5 : MIN(GetRLong(WDS_LIMIT),NENTRIES)
  424. #define ADD(bf,len) \
  425.     do {lastLen = len;if ((lastC=AddWDS(entries,¤t,bf,len,sendCount))<0) goto done;} while(0)
  426. #define SEND() do {if (sErr=SendEm(entries,¤t)) goto done;} while(0)
  427.  
  428. /************************************************************************
  429.  * AddWDS - add a string to the current set of WDS buffers
  430.  ************************************************************************/
  431. short AddWDS(WDSPtr entries, WDSPtr *current,Uptr bf,long len,short maxC)
  432. {
  433.     short lastC;
  434.     (*current)->ptr=bf; (*current)->length=len;
  435.     lastC = (bf)[len-1];
  436.     if (len && ++(*current)-entries == maxC-1)
  437.         if (sErr=SendEm(entries,current)) return(-1);
  438.     return(lastC);
  439. }
  440.  
  441. /************************************************************************
  442.  * SendEm - send the current set of WDS buffers
  443.  ************************************************************************/
  444. short SendEm(WDSPtr entries,WDSPtr *current)
  445. {
  446.     short err=0;
  447.     WDSPtr this;
  448.     long bytes;
  449.     
  450.     CycleBalls();
  451.     for (this=entries;this<*current;this++) bytes+=this->length;
  452.     if (bytes)
  453.     {
  454.         ByteProgress(nil,-bytes,0);
  455.         (*current)->length = 0;
  456.         err=SendWDS(entries);
  457.         *current=entries;
  458.     }
  459.     GiveTime();
  460.     return(err);
  461. }
  462.  
  463. /************************************************************************
  464.  * SendHeaderLine - send a line of header information to sendmail
  465.  ************************************************************************/
  466. int SendHeaderLine(int header,TEHandle teh)
  467. {
  468.     Str63 label, note;
  469.     UPtr start, stop, end, space, limit;
  470.     int lineLimit = GetRLong(WRAP_LIMIT);
  471.     UHandle safe=nil;
  472.     ENTRYDECLARATIONS;
  473.  
  474.     if (!(*teh)->teLength && header!=TO_HEAD) return(noErr);/* nothing here */
  475.     
  476.     /*
  477.      * label the header block
  478.      */
  479.     GetRString(label,HEADER_STRN+header);
  480.     ADD(label+1,*label);
  481.     
  482.     /*
  483.      * is it an address header?
  484.      */
  485.     if (header==TO_HEAD && !(*teh)->teLength)
  486.     {
  487.         GetRString(note,BCC_ONLY);
  488.         ADD(note+1,*note);
  489.         ADD(NewLine+1,*NewLine);
  490.     }
  491.     else if (IsAddressHead(header))
  492.     {
  493.         UHandle addresses;
  494.         UHandle rawAddresses = SuckAddresses((*teh)->hText,(*teh)->teLength,True);
  495.         int charsOnLine=0;
  496.         if (rawAddresses)
  497.         {
  498.             if (**rawAddresses)
  499.             {
  500.                 addresses = ExpandAliases(rawAddresses,0,True);
  501.                 DisposHandle(rawAddresses);
  502.                 if (addresses)
  503.                 {
  504.                     for (start=LDRef(addresses); *start; start += *start+2)
  505.                     {
  506.                         if (lineLimit && charsOnLine && *start+charsOnLine>lineLimit)
  507.                         {
  508.                             ADD(",",1);
  509.                             ADD(NewLine+1,*NewLine);
  510.                             charsOnLine = 0;
  511.                         }
  512.                         if (charsOnLine)
  513.                             ADD(", ",2);
  514.                         else
  515.                             ADD(" ",1);
  516.                         ADD(start+1,*start);
  517.                         charsOnLine += 1+*start;
  518.                     }
  519.                     ADD(NewLine+1,*NewLine);
  520.                     SEND();
  521.                 }
  522.                 DisposHandle(addresses);
  523.             }
  524.             else
  525.                 DisposHandle(rawAddresses);
  526.         }
  527.     }
  528.     else if (header==FROM_HEAD)
  529.     {
  530.         Handle popCanon=nil,returnCanon=nil;
  531.         Str31 sender;
  532.         Str255 buffer;
  533.         static UPtr unverified = " (Unverified)";    /* deliberately code-embedded */
  534.         
  535.         /* send the return address */
  536.         ADD(" ",1);
  537.         ADD(LDRef((*teh)->hText),(*teh)->teLength);
  538.         
  539.         if (*Password)
  540.         {
  541.             /* figure out what the return addr means */
  542.             returnCanon = SuckPtrAddresses(*(*teh)->hText,(*teh)->teLength,False);
  543.             
  544.             /* grab the POP account, and figure out what it means */        
  545.             GetPref(buffer,PREF_POP);
  546.             popCanon = SuckPtrAddresses(buffer+1,*buffer,False);
  547.         }
  548.         
  549.         /* if different or no password, send Sender field */
  550.         if (!UUPCOut && (!POPSecure || !EqualString(LDRef(popCanon),LDRef(returnCanon),False,True)))
  551.         {
  552.             ADD(NewLine+1,*NewLine);    /* finish From: header */
  553.             GetPref(buffer,PREF_POP);
  554.             GetRString(sender,SENDER);
  555.             ADD(sender+1,*sender);        /* send sender line, but not newline */
  556.             if (!UUPCIn) ADD(buffer+1,*buffer);
  557.             if (!POPSecure) ADD(unverified,13);
  558.         }
  559.         ADD(NewLine+1,*NewLine);
  560.         SEND();
  561.  
  562.         DisposHandle(popCanon);
  563.         DisposHandle(returnCanon);
  564.     }
  565.     else
  566.     {
  567.         if (header==ATTACH_HEAD && (safe=NewHandle((*teh)->teLength)))
  568.             BlockMove(*(*teh)->hText,*safe,(*teh)->teLength);
  569.         /*
  570.          * send it, a line at a time
  571.          * prepend a ' ' to each line, ala RFC 822
  572.          */
  573.         start = LDRef((*teh)->hText);
  574.         stop = start + (*teh)->teLength;
  575.         for (;start<stop;start=end+1)
  576.         {
  577.             limit = start + lineLimit;
  578.             if (stop<limit) limit = stop;
  579.             for (space=end=start;end<limit && *end!='\n'; end++)
  580.                 if (*end==' ') space=end;
  581.             if (space>start && end >= limit && limit<stop) end = space;
  582.             ByteProgress(nil,-1,0);
  583.             ADD(" ",1); ADD(start,end-start); ADD(NewLine+1,*NewLine);
  584.         }
  585.     }
  586.     if (current!=entries) SEND();
  587.     if (safe)
  588.     {
  589.         BlockMove(*safe,*(*teh)->hText,(*teh)->teLength);
  590.         DisposHandle(safe);
  591.     }
  592. done:
  593.     UL((*teh)->hText);
  594.     return(sErr); 
  595. }
  596.  
  597. /************************************************************************
  598.  * SendBodyLines - send the actual body of the message
  599.  *    Don't look at this; it's a mess.
  600.  *    text                Handle to the text to send
  601.  *    length            length of same
  602.  *  offset            offset at which to begin
  603.  *    doWrap            should the text be wrapped?
  604.  *    forceLines    should I force a newline at the end of the text?
  605.  *    lineStarts    pointer to array for determining wrap (may be nil)
  606.  *    nLines            length of same
  607.  *    partial            should I listen to the partial information?
  608.  ************************************************************************/
  609. int SendBodyLines(UHandle  text,long length,long offset,Boolean doWrap,Boolean forceLines,short *lineStarts,short nLines,Boolean partial)
  610. {
  611.     UPtr start;            /* the beginning of the text left to be sent */
  612.     UPtr stop;            /* the end of the entire text block */
  613.     UPtr end;                /* one past the last character of a line of text to be sent
  614.                                          for complete lines, this will be a return */
  615.     UPtr space;            /* the last space before end */
  616.     UPtr limit;            /* the point at which the line should be wrapped (if any) */
  617.     int lineLimit;    /* # of chars at which to wrap */
  618.     int quoteLimit;    /* ditto for quoted lines */
  619.     static short quoteLevel;        /* the # of quote chars at start of line */
  620.     Byte suspendChar;                        /* the quote character */
  621.     static short partialSize;        /* the size of the last line output, if it
  622.                                                                  was an incomplete line */
  623.     static Boolean softNewline;    /* was the last newline added by us? */
  624.     Str31 scratch;
  625.     short i;
  626.     ENTRYDECLARATIONS;
  627.     
  628.     if (!partial)
  629.     {
  630.         softNewline=False;    /* the caller has told us not to */
  631.         partialSize = 0;        /* bother with partial processing */
  632.     }
  633.     start = LDRef(text)+offset;
  634.     stop = *text + length;
  635.  
  636.     /*
  637.      * gather up important info for wrap calculations
  638.      */
  639.     if (doWrap)
  640.     {
  641.         suspendChar = (GetRString(scratch,QUOTE_PREFIX))[1];
  642.         lineLimit = GetRLong(WRAP_LIMIT);
  643.         quoteLimit = GetRLong(QUOTE_LIMIT);
  644.         
  645.         /*
  646.          * if this is a new line, count the quote level
  647.          */
  648.         if (!partialSize)
  649.         {
  650.             for (end = start;*end==suspendChar && end<stop;end++);
  651.             quoteLevel = end-start;
  652.         }
  653.     }
  654.     
  655.     /*
  656.      * main loop; loop through the buffer, sending one line at a time
  657.      */
  658.     for (; start<stop; start = end+1)
  659.     {
  660.         /*
  661.          * Rong wrapping; based on the textedit linestarts array
  662.          */
  663.         if (doWrap && lineStarts)
  664.         {
  665.             if (nLines<=0) end=stop;        /* a single line */
  666.             else
  667.             {
  668.                 nLines--, lineStarts++;            /* point us at the next line */
  669.                 end = *text+*lineStarts-1;
  670.             }
  671.         }
  672.         
  673.         /*
  674.          * normal wrapping; based on line length
  675.          */
  676.         else
  677.         {
  678.             /* calculate the spot before which we should wrap */
  679.             if (doWrap)
  680.                 limit = start + (quoteLevel ? quoteLimit : lineLimit) - partialSize;
  681.             
  682.             /* if we don't want wrapping, or there is less text than the wrap limit */
  683.             if (!doWrap || stop<limit) limit = stop;    /* no need to wrap */
  684.             
  685.             /*
  686.              * look through the buffer, from start to the calculated line limit
  687.              * keep track of the last space we see, since it's a potential wrap point
  688.              * if we find a return, we have a whole line, and can send it
  689.              */
  690.             if (doWrap)
  691.             {
  692.                 for (space=end=start;end<limit && *end!='\n'; end++)
  693.                     if (*end==' ' && doWrap) space=end;
  694.                 if (end >= limit &&        /* we went over the wrap limit */
  695.                       limit<stop &&            /* it wasn't a bogus wrap limit */
  696.                         space>start)            /* and we found a space */
  697.                     end = space;                /* Wrap it! */
  698.             }
  699.             else
  700.             {
  701.                 for (end=start;end<limit && *end!='\n'; end++);    /* just look for newlines */
  702.             }
  703.             
  704.             /*
  705.              * make special allowance for lines >wrap limit but < 80
  706.              */
  707.             if (!softNewline && limit<stop && end-start+partialSize<quoteLimit)
  708.             {
  709.                 UPtr nl;
  710.                 for (nl=end;nl<start+partialSize+quoteLimit && *nl!='\n';nl++);
  711.                 if (*nl=='\n' && nl<stop) end=nl;        /* extend to hard return */
  712.             }
  713.          
  714.             /* are we adding the newline?  We'll want to know for the next line. */
  715.             if (end<limit) softNewline = *end!='\n';
  716.         }
  717.         
  718.         /*
  719.          * at this point, start points at the beginning of the line to send,
  720.          * and end points one character past the end of the line to send
  721.          */
  722.         
  723.         /* escape initial periods, if need be */ 
  724.         if (!partialSize && !UUPCOut && end>start && *start=='.') ADD(".",1);
  725.         
  726.         /* if there is data to send, send it */
  727.         if (end>start) ADD(start,end-start);
  728.         
  729.         /*
  730.          * send the newline, unless we've run out of characters and so don't know
  731.          * if this should be a complete line or not
  732.          */
  733.         if (forceLines || end<stop) ADD(NewLine+1,*NewLine);
  734.         
  735.         /*
  736.          * We just put out a line, so we know we're starting fresh for
  737.          * the next one, if there is a next one
  738.          */
  739.         partialSize = 0;
  740.  
  741.         /*
  742.          * quoted line processing, if there are any chars left
  743.          */
  744.         if (end<stop)
  745.             /*
  746.              * if we sent out a complete line, peek at the next line to see how
  747.              * many quote characters it has
  748.              */
  749.             if (*end=='\n')
  750.             {
  751.                 UPtr p;
  752.                 for (p=end+1;*p==suspendChar && p<stop;p++);
  753.                 quoteLevel = p-end-1;
  754.             }
  755.             else    /* if we wrapped it, prequote the next line */
  756.             {
  757.                 for (i=0;i<quoteLevel;i++) ADD(&suspendChar,1);
  758.                 partialSize = quoteLevel;    /* guess we have a partial line after all */
  759.             }
  760.         
  761.         /*
  762.          * normally, end points at a newline (for complete lines) or space
  763.          * (for wrapped ones).  So, we normally skip the character end points
  764.          * to.  However, long solid lines or Rong-wrapped lines might not obey
  765.          * this behavior; adjust end back by one to make up for the increment
  766.          * we'll do in just a few cycles...
  767.          */
  768.         if (end<stop && *end!=' ' && *end!='\n') end--;
  769.     }
  770.     
  771.     /*
  772.      * all done with that buffer.  If the last character is a newline,
  773.      * we don't have much to do.  Otherwise, we may (forceLines) wish to
  774.      * newline-terminate, else we want to remember how long the line
  775.      * fragment we sent was
  776.      */
  777.     if (lastC!=NewLine[*NewLine])
  778.       if (forceLines) ADD(NewLine+1,*NewLine);
  779.         else partialSize = lastLen;
  780.         
  781.     /*
  782.      * send the last buffer(s)
  783.      */
  784.     if (current != entries) SEND();
  785. done:
  786.     UL(text);
  787.     return(sErr); 
  788. }
  789.  
  790. /************************************************************************
  791.  * PrimeProgress - get the progress window started.
  792.  ************************************************************************/
  793. void PrimeProgress(MessType **messH)
  794. {
  795.     Str255 buff;
  796.     
  797.     *buff = 0;
  798.     PCat(buff,*((WindowPeek)(*messH)->win)->titleHandle);
  799.     ByteProgress(buff,0,CountCompBytes(messH));
  800. }
  801.  
  802.  
  803. /************************************************************************
  804.  * WannaSend - find out of the user wants to send a dirty window
  805.  ************************************************************************/
  806. int WannaSend(MyWindowPtr win)
  807. {
  808.     Str255 title;
  809.     
  810.     PCopy(title,*win->qWindow.titleHandle);
  811.     return(AlertStr(WANNA_SEND_ALRT,Stop,title));
  812. }
  813.  
  814. /************************************************************************
  815.  * SendAttachments - send the files the user has attached to his message.
  816.  ************************************************************************/
  817. int SendAttachments(TEHandle teh,Boolean doWrap,Boolean plainText)
  818. {
  819.     short colons[4];
  820.     short onColon;
  821.     Str31 name;
  822.     Str31 volName;
  823.     long id;
  824.     int err;
  825.     int onChar;
  826.     UHandle text = (*teh)->hText;
  827.     
  828.     onColon = 0;
  829.     for (onChar=0;onChar<(*teh)->teLength;onChar++)
  830.         if ((*text)[onChar] == ':')
  831.         {
  832.             colons[onColon] = onChar;
  833.             if (++onColon==sizeof(colons)/sizeof(short))
  834.             {
  835.                 BlockMove((*text)+colons[0]+1,volName+1,colons[1]-colons[0]);
  836.                 *volName = colons[1]-colons[0];
  837.                 id = atoi(LDRef(text)+colons[1]+1);
  838.                 BlockMove((*text)+colons[2]+1,name+1,colons[3]-colons[2]-1);
  839.                 *name = colons[3]-colons[2]-1;
  840.                 UL(text);
  841.                 if (plainText && IsText(volName,id,name))
  842.                     err = SendPlain(GetMyVR(volName),id,name,doWrap);
  843.                 else
  844.                     err = SendBinHex(GetMyVR(volName),id,name);
  845.                 if (err) return(err);
  846.                 onColon = 0;
  847.             }
  848.         }
  849.     return(noErr);
  850. }
  851.  
  852. /************************************************************************
  853.  * GrabSignature - read the signature file
  854.  ************************************************************************/
  855. void GrabSignature(void)
  856. {
  857.     Str31 name;
  858.     short refN,err,vRef;
  859.     long dirId;
  860.     long bytes;
  861.     
  862.  
  863.     if (err=GetFileByRef(SettingsRefN,&vRef,&dirId,name))
  864.         FileSystemError(READ_SETTINGS,name,err);
  865.     else if (err=FSHOpen(name,MyVRef,MyDirId,&refN,fsRdPerm))
  866.         FileSystemError(READ_SETTINGS,name,err);
  867.     else
  868.     {
  869.         if (err=GetEOF(refN,&bytes))
  870.             FileSystemError(READ_SETTINGS,name,err);
  871.         else if (bytes)
  872.         {
  873.             if (!(Signature = NuHandle(bytes)))
  874.                 WarnUser(MEM_ERR,err=MemError());
  875.             else
  876.             {
  877.                 if (err=FSRead(refN,&bytes,LDRef(Signature)))
  878.                 {
  879.                     FileSystemError(READ_SETTINGS,name,err);
  880.                     ZapHandle(Signature);
  881.                 }
  882.             }
  883.         }
  884.         FSClose(refN);
  885.     }
  886. }
  887. /************************************************************************
  888.  * SendPlain - send a plain text file
  889.  ************************************************************************/
  890. short SendPlain(short vRef,long dirId,UPtr name,Boolean doWrap)
  891. {
  892.     short refN=0;
  893.     UHandle dataBuffer=nil;
  894.     short dataSize;
  895.     int err;
  896.     short oldVol;
  897.     short newVol;
  898.     long fileSize,sendSize,readSize;
  899.     Str63 scratch;
  900.     Boolean partial = False;
  901.     
  902.     GetVol(scratch,&oldVol);
  903.     if (err=HSetVol(nil,vRef,dirId))
  904.         {FileSystemError(BINHEX_OPEN,name,err); goto done;}
  905.     GetVol(scratch,&newVol);
  906.     
  907.     /*
  908.      * allocate the buffers
  909.      */
  910.     dataSize = GetRLong(BUFFER_SIZE);
  911.     if (!(dataBuffer=NuHandle(dataSize)))
  912.         {WarnUser(MEM_ERR,MemError()); goto done;}
  913.  
  914.     ComposeRString(scratch,PLAIN_PROG_FMT,name);
  915.     PushProgress();
  916.     Progress(0,scratch);
  917.     
  918.     /*
  919.      * open it
  920.      */
  921.     if (err = FSHOpen(name,vRef,dirId,&refN,fsRdPerm))
  922.         {FileSystemError(BINHEX_OPEN,name,err); goto done;}
  923.     if (err = GetEOF(refN,&fileSize))
  924.         {FileSystemError(BINHEX_OPEN,name,err); goto done;}
  925.     
  926.     /*
  927.      * send it
  928.      */
  929.     ByteProgress(nil,0,fileSize);
  930.     for (;fileSize;fileSize-=readSize)
  931.     {
  932.         readSize=MIN(dataSize,fileSize);
  933.         sendSize = readSize;
  934.         if (err=FSRead(refN,&sendSize,LDRef(dataBuffer)))
  935.             {FileSystemError(BINHEX_READ,name,err); goto done;}
  936.         UL(dataBuffer);
  937.         if (SendBodyLines(dataBuffer,sendSize,0,doWrap,False,nil,0,partial))
  938.             goto done;
  939.         partial = (*dataBuffer)[sendSize-1] != '\n';
  940.     }
  941.     SendTrans(1,NewLine+1,*NewLine);
  942.     
  943.     
  944. done:
  945.     if (refN) FSClose(refN);
  946.     if (dataBuffer) DisposHandle(dataBuffer);
  947.     PopProgress(False);
  948.     SetVol(nil,oldVol);
  949.     return(err);    
  950. }             
  951.  
  952. /************************************************************************
  953.  * BuildDateHeader - build an RFC 822 date header
  954.  ************************************************************************/
  955. void BuildDateHeader(UPtr buffer,long seconds)
  956. {
  957.     DateTimeRec dtr;
  958.     long delta = ZoneSecs();
  959.     Boolean negative;
  960.     
  961.     if (delta==-1) {*buffer=0;return;}
  962.     if (seconds)
  963.         Secs2Date(seconds+delta,&dtr);
  964.     else
  965.         GetTime(&dtr);
  966.     if (negative=delta<0) delta *= -1;
  967.     delta /= 60; /* we want minutes */
  968.     ComposeRString(buffer,DATE_HEADER,
  969.                                             WEEKDAY_STRN+dtr.dayOfWeek,
  970.                                             dtr.day,
  971.                                             MONTH_STRN+dtr.month,
  972.                                             dtr.year,
  973.                                             dtr.hour/10, dtr.hour%10,
  974.                                             dtr.minute/10, dtr.minute%10,
  975.                                             dtr.second/10, dtr.second%10,
  976.                                             negative ? '-' : '+',
  977.                                             delta/600,(delta%600)/60,(delta%60)/10,delta%10);
  978.     return;
  979. }             
  980.  
  981. /************************************************************************
  982.  * SaveB4Send - grab an outgoing message, saving if necessary
  983.  ************************************************************************/
  984. MessHandle SaveB4Send(TOCHandle tocH,short sumNum)
  985. {
  986.     short which;
  987.     MessHandle messH = (MessHandle)(*tocH)->sums[sumNum].messH;
  988.     
  989.     if (messH && (*messH)->win->isDirty)
  990.     {
  991.         which = WannaSend((*messH)->win);
  992.         if (which == WANNA_SAVE_CANCEL || which==CANCEL_ITEM)
  993.             return (nil);
  994.         else if (which == WANNA_SAVE_SAVE && !SaveComp((*messH)->win))
  995.             return(nil);
  996.         else if (which == WANNA_SAVE_DISCARD)
  997.         {
  998.             (*messH)->win->isDirty = False;
  999.             CloseMyWindow((*messH)->win);
  1000.             messH = nil;
  1001.         }     
  1002.     }
  1003.     if (!messH)
  1004.     {
  1005.         if (!OpenComp(tocH,sumNum,nil,False)) return(nil);
  1006.         messH = (MessHandle)(*tocH)->sums[sumNum].messH;
  1007.     }
  1008.     return(messH);
  1009. }
  1010.  
  1011. /************************************************************************
  1012.  * TimeStamp - put a time stamp on a message
  1013.  ************************************************************************/
  1014. void TimeStamp(TOCHandle tocH,short sumNum,uLong when,long delta)
  1015. {
  1016.     PtrTimeStamp(LDRef(tocH)->sums+sumNum,when,delta);
  1017.     UL(tocH);
  1018.     CalcSumLengths(tocH,sumNum);
  1019.     InvalSum(tocH,sumNum);
  1020.     (*tocH)->dirty = True;
  1021. }
  1022.  
  1023. /************************************************************************
  1024.  * PtrTimeStamp - timestamp, but into a sum directly
  1025.  ************************************************************************/
  1026. void PtrTimeStamp(MSumPtr sum,uLong when,long delta)
  1027. {
  1028.     sum->seconds = when;
  1029.     if (when)
  1030.     {
  1031.         /* put the date into the summary */
  1032.         Str31 d1, d2, d3;
  1033.         Str63 fmt;
  1034.         long secs = when + delta;
  1035.         Boolean neg = delta < 0;
  1036.         
  1037.         IUTimeString(secs,False,d1);
  1038.         IUDateString(secs,shortDate,d2);
  1039.         
  1040.         if (neg) delta *= -1;
  1041.         delta /= 60;    /* minutes*/
  1042.         ComposeString(d3,"\p%c%d%d%d%d",neg?'-':'+',
  1043.                                             delta/600,(delta%600)/60,(delta%60)/10,delta%10);
  1044.  
  1045.         GetRString(fmt,DATE_SUM_FMT);
  1046.         if (d1[2]<'0' || d1[2]>'9') {BlockMove(d1+1,d1+2,*d1+1);++*d1;d1[1]=optSpace;}
  1047.         utl_PlugParams(fmt,sum->date,d1,d2,d3,nil);
  1048.     }
  1049.     else
  1050.       sum->date[0] = 0;
  1051. }
  1052.  
  1053.